#include "..\..\Header\GamePlay\general.h"
int XPLACEMENT_BATIMENT = 400;
using namespace sf;
using namespace std;
Vue::Vue(sf::Vector2f centre, sf::Vector2f demitaille)
{
    m_vue = new View;
    m_vue->setCenter(centre);
    m_vue->setSize(demitaille.x * 2, demitaille.y * 2);
}
sf::View Vue::getvue()
{
    return *m_vue;
}
void Vue::deplacer(int valeur, Terrain *terre)
{
    if(m_vue->getCenter().x+valeur < 400)
        m_vue->setCenter(400,300);
    else if(m_vue->getCenter().x+valeur > terre->GetTextureSize().x-400)
        m_vue->setCenter(terre->GetTextureSize().x-400,300);
    else
        m_vue->move(valeur,0);
}
void Vue::setPosition(int x, Terrain *terre)
{
    int x2 = terre->GetTextureSize().x;
    if(x < 400)
        m_vue->setCenter(400,300);
    else if(x>x2-400)
        m_vue->setCenter(x2-400,300);
    else
        m_vue->setCenter(x,300);
}
/*
Class Equipe :
Description : Cette classe contient toute les informations d'une equipe et permet la gestion simple de l'equipe.
*/
Equipe::Equipe()
{
    is_Alive = false;
    is_Ia = false;
    Explosion_resistance = false;
    Explosion_damage = false;
    unite_actuel = 0;
    vie = 0;
    point = 8000;
    vie_total = 0;
    m_batiment.push_back(new Batiment("picture/map/base.png",2000,0));
}
Equipe::~Equipe()
{
}
void Equipe::Afficher(sf::RenderWindow *app, int id, bool visible)
{
    m_batiment[id]->Afficher(app, visible);
}
Batiment Equipe::GetBatiment(int id)
{
    if(id < m_batiment.size())
        return *m_batiment[id];
}
void Equipe::GetXmaxmin(int *max, int *min)
{
    *max = xmax;
    *min = xmin;
}
void Equipe::SetBasePosition(float x, Terrain *terre)
{
    m_batiment[0]->Placer(x, terre->cherTerrain(x,-1), true);
    xmin = x-XPLACEMENT_BATIMENT;
    xmax = x+XPLACEMENT_BATIMENT;
}
int Equipe::GetNumberBatiment()
{
    return m_batiment.size();
}
void Equipe::AddBatiment(std::vector<Unite*> m_unite)
{
    In_to_Create_Batiment = false;
    point -= m_prix;
    m_prix = 0;
    if(m_batiment[m_batiment.size()-2]->GetPosition().x < m_tmp_position.x)
        xmax = m_tmp_position.x+XPLACEMENT_BATIMENT;
    else
        xmin = m_tmp_position.x-XPLACEMENT_BATIMENT;
    for(int k(0);k<unite_id.size(); k++)
    switch(m_batiment[m_batiment.size()-1]->GetType())
    {
        case 2:
        if(m_unite[unite_id[k]]->GetType() == INFANT)
            m_unite[unite_id[k]]->SetBonus(100,BS_VIEMAX);
        break;

        case 4:
        if(m_unite[unite_id[k]]->GetType() == INFANT)
            m_unite[unite_id[k]]->SetBonus(50,BS_PUISSANCEMAX);
        break;

        case 6:
        m_unite[unite_id[k]]->SetBonus(1.5,BS_DEPLACEMENT);
        break;

        case 7:
        Explosion_resistance = true;
        break;

        case 8:
        if(m_unite[unite_id[k]]->GetType() != INFANT)
            m_unite[unite_id[k]]->SetBonus(200,BS_VIEMAX);
        break;

        case 9:
        Explosion_damage = true;
        break;

        default:
        break;
    }
    m_batiment[m_batiment.size()-1]->Placer(m_tmp_position.x, m_tmp_position.y, true);
}
void Equipe::CreateBatiment(int type, int sous_type, sf::Vector2f position, Terrain *terre)
{
    int prix;
    switch(type)
    {
        case MEDIC:
        prix = 1200;
        break;

        case SNIPER:
        prix = 1500;
        break;

        case TECH:
        prix = 1300;
        break;

        case SOLDAT:
        prix = 1600;
        break;

        default:
        prix = 750;
        break;
    }
    if(point >= prix)
    {
        m_prix = prix;
        In_to_Create_Batiment = true;
        m_tmp_type = type;
        m_tmp_sous_type = sous_type;
        m_tmp_position = sf::Vector2f(position.x,terre->cherTerrain(position.x,-1));
        if(type == MEDIC)
        {
            m_batiment.push_back(new Batiment("picture/batiment/hopital.png", 1000, 2+sous_type));
            m_batiment[m_batiment.size()-1]->Placer(m_tmp_position.x, m_tmp_position.y,false);
        }
        else if(type == SNIPER)
        {
            m_batiment.push_back(new Batiment("picture/batiment/radart.png", 1300, 4+sous_type));
            m_batiment[m_batiment.size()-1]->Placer(m_tmp_position.x, m_tmp_position.y,false);
        }
        else if(type == SOLDAT)
        {
            m_batiment.push_back(new Batiment("picture/batiment/armurerie.png", 2000, 6+sous_type));
            m_batiment[m_batiment.size()-1]->Placer(m_tmp_position.x, m_tmp_position.y,false);
        }
        else if(type == TECH)
        {
            m_batiment.push_back(new Batiment("picture/batiment/garage.png", 2000, 8+sous_type));
            m_batiment[m_batiment.size()-1]->Placer(m_tmp_position.x, m_tmp_position.y,false);
        }
        else
        {
            m_batiment.push_back(new Batiment("picture/batiment/pompe.png", 700, 10));
            m_batiment[m_batiment.size()-1]->Placer(m_tmp_position.x, m_tmp_position.y,false);
        }
    }
}

void Equipe::AddUniteId(int id, std::vector<Unite*> m_unite)
{
    unite_id.push_back(id);
    vie_total += m_unite[id]->GetVieMax();
    vie = vie_total;
    is_Alive = true;
}
void Equipe::SetIa(bool ia)
{
    is_Ia = ia;
}
bool Equipe::IsExplosion(int type)
{
    if(type == 1)
        return Explosion_resistance;
    else
        return Explosion_damage;
}
void Equipe::RafraichirEffect(std::vector<Unite*> m_unite, Terrain *terre)
{
    int i(0);
    for(i=0; i<unite_id.size(); i++)
    {
        if(unite_id[i] != -1)
        {
            if(!m_unite[unite_id[i]]->IsDead())
            {
                for(int k(0);k<m_batiment.size();k++)
                {
                    if(m_batiment[k]->GetType()==3)
                        if(m_batiment[k]->IsCollideUnite(m_unite[unite_id[i]]->GetSurface()) && m_unite[unite_id[i]]->GetType()==INFANT)
                            m_unite[unite_id[i]]->Soin(20);
                }
            }
        }
    }
    for(int j(0);j<m_batiment.size();j++)
    {
        if(m_batiment[j]->GetVie()<=0)
        {
            for(int k(0);k<unite_id.size();k++)
                switch(m_batiment[j]->GetType())
                {
                    case 2:
                    if(m_unite[unite_id[k]]->GetType() == INFANT)
                        m_unite[unite_id[k]]->SetBonus(0,BS_VIEMAX);
                    break;

                    case 4:
                    if(m_unite[unite_id[k]]->GetType() == INFANT)
                        m_unite[unite_id[k]]->SetBonus(0,BS_PUISSANCEMAX);
                    break;

                    case 6:
                    m_unite[unite_id[k]]->SetBonus(0,BS_DEPLACEMENT);
                    break;

                    case 7:
                    Explosion_resistance = false;
                    break;

                    case 8:
                    if(m_unite[unite_id[k]]->GetType() != INFANT)
                        m_unite[unite_id[k]]->SetBonus(0,BS_VIEMAX);
                    break;

                    case 9:
                    Explosion_damage = false;
                    break;

                    default:
                    break;
                }
            m_batiment.erase(m_batiment.begin()+j);
        }
    }
    for(int k(0);k<m_batiment.size();k++)
    {
        if(m_batiment[k]->GetType()==0)
            point += 200;
        if(m_batiment[k]->GetType()==10)
        {
            if(terre->GetPuit(m_batiment[k]->GetPosition().x)->GetFuel()>0)
            {
                terre->GetPuit(m_batiment[k]->GetPosition().x)->ReduireFuel();
                point += 100;
            }
        }
    }
}
void Equipe::Achat(int prix)
{
    point -= prix;
}
void Equipe::Rafraichir(std::vector<Unite*> m_unite)
{
    int mort(0);
    int i(0);
    vie = 0;
    for(i=0; i<unite_id.size(); i++)
    {
        if(unite_id[i] != -1)
        {
            if(m_unite[unite_id[i]]->IsDead())
            {
                unite_id[i] = -1;
                mort++;
            }
            else
            {
                m_unite[unite_id[i]]->SetFire(false);
                m_unite[unite_id[i]]->SetPuissance(100);
                m_unite[unite_id[i]]->SetCreateBatiment(true);
                vie+= m_unite[unite_id[i]]->GetVie();
            }
        }
        else
        {
            mort++;
        }
    }
    if(i == mort)
        is_Alive = false;
    if(unite_id[unite_actuel] == -1 && is_Alive)
        Suivant();
}
int Equipe::GetUniteActuel()
{
    return unite_id[unite_actuel];
}
int Equipe::GetUniteTotal()
{
    return unite_id.size();
}
int Equipe::GetUnite(int id)
{
    return unite_id[id];
}
void Equipe::Suivant()
{
    do
    {
        if(unite_actuel + 1 == unite_id.size())
        {
            unite_actuel = 0;
        }
        else
            unite_actuel++;
    }while (unite_id[unite_actuel] == -1);
}
void Equipe::Precedent()
{
    do
    {
        if(unite_actuel == 0)
        {
            unite_actuel = unite_id.size()-1;
        }
        else
            unite_actuel--;
    }while (unite_id[unite_actuel] == -1);
}
bool Equipe::GetAlive()
{
    return is_Alive;
}
int Equipe::GetPoint()
{
    return point;
}
bool Equipe::GetIa()
{
    return is_Ia;
}
float Equipe::GetPourcentVie()
{
    return (vie/vie_total)*100;
}
bool Equipe::CanPlaceBatiment(sf::Vector2f position, Terrain *terre)
{
    for(int i(0);i<m_batiment.size()-1;i++)
    {
        if(m_batiment[m_batiment.size()-1]->IsCollideUnite(m_batiment[i]->GetSprite()))
            return false;
    }
    if(terre->InPuit(position.x) && m_batiment[m_batiment.size()-1]->GetType() == 10)
    {
        return true;
    }
    else if(m_batiment[m_batiment.size()-1]->GetType() == 10)
    {
        return false;
    }
    if(m_batiment[m_batiment.size()-1]->Placeable(position.x, terre, xmax, xmin))
    {
        return true;
    }
    return false;
}
void Equipe::PlacerBatiment(int id,bool placeable, bool placer, sf::Vector2f position)
{
    if(id < m_batiment.size())
    {
        m_tmp_position = position;
        m_batiment[id]->SetPlaceable(placeable);
        m_batiment[id]->Placer(position.x, position.y, placer);
    }
}
Game::Game(std::string fichier)
{
    enPause = false;
    vue_suivit = true;
    curseur_interface = 50;
    fenetre = new Vue(sf::Vector2f(400,300),sf::Vector2f(400,300));
    for(int i(0); i<4; i++)
    {
        equipe_id[i] = Equipe();
    }
    //Chargement des images du menu pause
    if(!image_boutonpause.loadFromFile("Picture/map/menu_pause.png"))
    {
        cout << "Erreur dans le chargement de l'image du menu pause" << endl;
    }
    else
    {
        sprite_boutonoption.setTexture(image_boutonpause);
        sprite_boutonoption.setTextureRect(IntRect(0,150,200,200));
        sprite_boutonoption.setPosition(300,250);

        sprite_boutonquitter.setTexture(image_boutonpause);
        sprite_boutonquitter.setTextureRect(IntRect(0,0,200,50));
        sprite_boutonquitter.setPosition(300,350);

        sprite_boutonreprendre.setTexture(image_boutonpause);
        sprite_boutonreprendre.setTextureRect(IntRect(0,50,200,100));
        sprite_boutonreprendre.setPosition(300,200);

        sprite_boutonretourmenu.setTexture(image_boutonpause);
        sprite_boutonretourmenu.setTextureRect(IntRect(0,100,200,150));
        sprite_boutonretourmenu.setPosition(300,300);
    }
    if(!image_fondpause.loadFromFile("Picture/map/fond_pause.png"))
    {
        cout << "Erreur dans le chargement du fond du menu pause." << endl;
    }
    else
    {
        sprite_fondpause.setTexture(image_fondpause);
        sprite_fondpause.setPosition(0,0);
    }
    if(!font.loadFromFile("font.ttf"))
    {
        cout << "Erreur aucune police d'écriture n'est charger." << endl;
    }
    else
    {
        rate.setFont(font);
        rate.setCharacterSize(25);
        rate.setPosition(750,0);
    }
    //Chargement des images des equipes
    if(!image_equipe.loadFromFile("Picture/map/equipe_vie.png"))
    {
        cout << "Erreur dans le chargement de l'image de l'affichage de l'équipe" << endl;
    }
    else
    {
        for(int i(0); i<4; i++)
        {
            sprite_fondequipe[i].setTexture(image_equipe);
            sprite_devantequipe[i].setTexture(image_equipe);
            sprite_vieequipe[i].setTexture(image_equipe);
            sprite_devantequipe[i].setTextureRect(IntRect(0,i*140,400,i*140 + 40));
            sprite_fondequipe[i].setTextureRect(IntRect(0,i*140 + 40,400,i*140 + 90));
            sprite_vieequipe[i].setTextureRect(IntRect(0,i*140 + 90,386,i*140 + 140));
            sprite_fondequipe[i].setScale(0.5,0.5);
            sprite_vieequipe[i].setScale(0.5,0.5);
            sprite_devantequipe[i].setScale(0.5,0.5);
            texte_equipe[i].setColor(Color(0,0,0));
            texte_equipe[i].setFont(font);
            texte_equipe[i].setCharacterSize(25);
        }
        texte_equipe[0].setString("ROUGE");
        texte_equipe[1].setString("BLEU");
        texte_equipe[2].setString("VERT");
        texte_equipe[3].setString("JAUNE");
    }
    if(!image_tableauequipe.loadFromFile("Picture/map/tableau_equipe.png"))
    {
        cout << "Erreur dans le chargement du tableau equipe" << endl;
    }
    else
    {
        sprite_tableauequipe.setTexture(image_tableauequipe);
        texte_nomequipe.setFont(font);
        texte_nomunite.setFont(font);
        texte_nomequipe.setCharacterSize(20);
        texte_nomunite.setCharacterSize(18);
    }
    if(!image_changementequipe.loadFromFile("Picture/map/changement_equipe.png"))
    {
        cout << "Erreur dans le chargement du changement d'équipe" << endl;
    }
    else
    {
        sprite_changementequipe.setTexture(image_changementequipe);
        texte_changementequipe.setFont(font);
        texte_changementequipe.setCharacterSize(60);
    }
    if(!image_curseur.loadFromFile("Picture/map/curseur.png"))
    {
        cout << "Impossible de charger le curseur" << endl;
    }
    else
    {
        sprite_curseur.setTexture(image_curseur);
        sprite_curseur.setOrigin(sprite_curseur.getLocalBounds().width/2, sprite_curseur.getLocalBounds().height/2);
    }
    if(!image_fond.loadFromFile("picture/menu/ingame_interface.png"))
    {
        cout << "Impossible de charger de fond..." << endl;
    }
    else
    {
        sprite_fond.setTexture(image_fond);
        sprite_fond.setPosition(0,600-curseur_interface);
    }
    if(!image_fond_devant.loadFromFile("picture/menu/ingame_interface_dessus.png"))
    {
        cout << "Impossible de charger de fond..." << endl;
    }
    else
    {
        sprite_fond_devant.setTexture(image_fond_devant);
        sprite_fond_devant.setPosition(0,600-curseur_interface);
    }
    if(!image_jauge.loadFromFile("picture/menu/jauge.png"))
    {
        cout << "Impossible de charger de fond..." << endl;
    }
    else
    {
        sprite_vie_base.setTexture(image_jauge);
        sprite_vie_unite.setTexture(image_jauge);
        sprite_puissance.setTexture(image_jauge);
        sprite_vie_unite.setPosition(20,600-45-curseur_interface+120);
        sprite_puissance.setPosition(20,600-30-curseur_interface+120);
        sprite_vie_base.setPosition(230,600-30-curseur_interface+120);
        sprite_vie_base.setTextureRect(IntRect(0,0,190,10));
        sprite_vie_unite.setTextureRect(IntRect(0,10,145,20));
        sprite_puissance.setTextureRect(IntRect(0,20,145,30));
    }
    if(!image_bouton.loadFromFile("picture/menu/bouton_interface.png"))
    {
        cout << "impossible de charger les boutons" << endl;
    }
    else
    {
        sprite_hopital.setTexture(image_bouton);
        sprite_hopital.setTextureRect(IntRect(0,40,20,60));
        sprite_garage.setTexture(image_bouton);
        sprite_garage.setTextureRect(IntRect(0,60,20,80));
        sprite_armurerie.setTexture(image_bouton);
        sprite_armurerie.setTextureRect(IntRect(0,0,20,20));
        sprite_radar.setTexture(image_bouton);
        sprite_radar.setTextureRect(IntRect(0,20,20,40));
        sprite_pompe.setTexture(image_bouton);
        sprite_pompe.setTextureRect(IntRect(0,80,20,100));
        sprite_c4.setTexture(image_bouton);
        sprite_c4.setTextureRect(IntRect(0,120,20,140));
        sprite_soin.setTexture(image_bouton);
        sprite_soin.setTextureRect(IntRect(0,160,20,180));
        sprite_reparation.setTexture(image_bouton);
        sprite_reparation.setTextureRect(IntRect(0,200,20,220));
    }
    texte_point.setFont(font);
    texte_point.setCharacterSize(15);
    texte_nbbatiment.setFont(font);
    texte_nbbatiment.setCharacterSize(15);
    texte_statut.setFont(font);
    texte_statut.setCharacterSize(15);
    texte_point.setColor(sf::Color::White);
    texte_nbbatiment.setColor(sf::Color::White);
    texte_statut.setColor(sf::Color::White);
    m_terre = new Terrain();
    m_terre->SetFichier(fichier);
    nombre_joueur = 0;
    tour = 0;
    equipe_actu = 0;
    equipe_gagnante = 0;
}
Game::~Game()
{
}
void Game::setFichier(std::string fichier)
{
    m_terre->SetFichier(fichier);
}
void Game::addUnite(Unite *unite)
{
    m_unite.push_back(unite);
    m_spriteunite.push_back(unite->GetSurface());
    equipe_id[unite->GetEquipe()-1].AddUniteId(m_unite.size()-1,m_unite);
}
void Game::boucle(sf::RenderWindow *app, int ia)
{
    int equipe_tmp(4);
    Batiment bunker("picture/batiment/bunker.png",500,1);
    bunker.ChargerCaractere("picture/batiment/bunker.bfile");
    bunker.Placer(4900, m_terre->cherTerrain(4900,-1), true);
    m_batiment_neutre.push_back(bunker);
    for(int i(0); i < ia; i++)
    {
        if(equipe_id[equipe_tmp-i].GetAlive())
        {
            equipe_id[equipe_tmp-i].SetIa(true);
        }
        else
        {
            i--;
            equipe_tmp--;
        }
    }
    int unite = 0;
    typePause = 0;
    int attente = 0;
    bool Cliquedroit = false, ToucheOn = false;
    srand(time(NULL));
    for(int i(0); i<m_unite.size();i++)
    {
            int random = rand()%200 - 100;
            int helico_plus = -rand()%100;
            if(m_unite[i]->GetType() != HELICO)
                helico_plus = 0;
            else
                helico_plus -= 10;
            switch(m_unite[i]->GetEquipe())
            {
                case ROUGE:
                    m_unite[i]->SetPosition(sf::Vector2f(m_terre->GetBaseSize(ROUGE).x+random,m_terre->GetBaseSize(ROUGE).y+helico_plus));
                    equipe_id[0].SetBasePosition(m_terre->GetBaseSize(ROUGE).x, m_terre);
                    if(nombre_joueur == 0)
                        nombre_joueur++;
                    break;
                case BLEU:
                    m_unite[i]->SetPosition(sf::Vector2f(m_terre->GetBaseSize(BLEU).x+random,m_terre->GetBaseSize(BLEU).y+helico_plus));
                    equipe_id[1].SetBasePosition(m_terre->GetBaseSize(BLEU).x, m_terre);
                    if(nombre_joueur <= 1)
                        nombre_joueur=2;
                    break;
                case VERT:
                    m_unite[i]->SetPosition(sf::Vector2f(m_terre->GetBaseSize(VERT).x+random,10+m_terre->GetBaseSize(VERT).y+helico_plus));
                    equipe_id[2].SetBasePosition(m_terre->GetBaseSize(VERT).x, m_terre);
                    if(nombre_joueur <= 2)
                        nombre_joueur=3;
                    break;
                case JAUNE:
                    m_unite[i]->SetPosition(sf::Vector2f(m_terre->GetBaseSize(JAUNE).x+random,10+m_terre->GetBaseSize(JAUNE).y+helico_plus));
                    equipe_id[3].SetBasePosition(m_terre->GetBaseSize(JAUNE).x, m_terre);
                    if(nombre_joueur <= 3)
                        nombre_joueur=4;
                    break;
            }
            if(m_unite[i]->GetType() == TANK)
            {
                m_unite[i]->Physique(m_terre, 1);
            }
            else if(m_unite[i]->GetType() == INFANT)
                m_unite[i]->Physique(m_terre, 0);
    }
    bool tmp_cliquedroit = true;
    if(app->isOpen())
    while(app->isOpen())
    {
        texte_statut.setString("");
        sf::Vector2f souris = (sf::Vector2f)sf::Mouse::getPosition();
        if(equipe_gagnante > 0)
        {
            app->close();
        }
        unite = equipe_id[equipe_actu].GetUniteActuel();
        //Evenement
        if(!enPause)
        {
            if(sf::Keyboard::isKeyPressed(sf::Keyboard::Z))
                m_unite[unite]->Evenement(1, app, m_terre, this);

            if(sf::Keyboard::isKeyPressed(sf::Keyboard::S))
                m_unite[unite]->Evenement(2, app, m_terre, this);

            if(sf::Keyboard::isKeyPressed(sf::Keyboard::D))
            {
                m_unite[unite]->Evenement(3, app, m_terre, this);
                if(m_unite[unite]->GetType() == TANK)
                {
                    m_unite[unite]->Physique(m_terre, 1);
                }
                else if(m_unite[unite]->GetType() == INFANT)
                    m_unite[unite]->Physique(m_terre, 1);
            }
            if(sf::Keyboard::isKeyPressed(sf::Keyboard::Q))
            {
                m_unite[unite]->Evenement(4, app, m_terre, this);
                if(m_unite[unite]->GetType() == TANK)
                {
                    m_unite[unite]->Physique(m_terre, 1);
                }
                else if(m_unite[unite]->GetType() == INFANT)
                    m_unite[unite]->Physique(m_terre, 0);
            }
            if(sf::Keyboard::isKeyPressed(sf::Keyboard::LControl))
                m_unite[unite]->Evenement(7, app, m_terre, this);

            if(sf::Keyboard::isKeyPressed(sf::Keyboard::LShift))
                m_unite[unite]->Evenement(8, app, m_terre, this);

            if((!sf::Keyboard::isKeyPressed(sf::Keyboard::Q) && !sf::Keyboard::isKeyPressed(sf::Keyboard::D)) || (sf::Keyboard::isKeyPressed(sf::Keyboard::Q) && sf::Keyboard::isKeyPressed(sf::Keyboard::D)))
                m_unite[unite]->Evenement(6, app, m_terre, this);

            if((!sf::Keyboard::isKeyPressed(sf::Keyboard::Z) && !sf::Keyboard::isKeyPressed(sf::Keyboard::S)) || (sf::Keyboard::isKeyPressed(sf::Keyboard::Z) && sf::Keyboard::isKeyPressed(sf::Keyboard::S)))
                m_unite[unite]->Evenement(-1, app, m_terre, this);
        }
        if(sf::Mouse::isButtonPressed(sf::Mouse::Left))
        {
            if(souris.x > sprite_puissance.getPosition().x && souris.x < sprite_puissance.getPosition().x+145
               && souris.y > sprite_puissance.getPosition().y && souris.y < sprite_puissance.getPosition().y+10)
            {
                float tmp_puissance;
                tmp_puissance = sf::Mouse::getPosition().x-sprite_puissance.getPosition().x;
                tmp_puissance = tmp_puissance/145*100;
                if(m_unite[unite]->GetType() == TANK)
                    texte_statut.setString("Puissance de tir = "+to_string(tmp_puissance)+"%");
                else
                    texte_statut.setString("Pas de puissance de tir sur cette unite");
                cout << tmp_puissance << endl;
                m_unite[unite]->SetPuissance(tmp_puissance);
                sprite_puissance.setTexture(image_jauge);
                sprite_puissance.setTextureRect(IntRect(0,20,sf::Mouse::getPosition().x-sprite_puissance.getPosition().x,30));
            }
        }
        Cliquedroit = false;
        if(sf::Mouse::isButtonPressed(sf::Mouse::Left) && tmp_cliquedroit)
        {
            Cliquedroit = true;
            tmp_cliquedroit = false;
        }
        else if(!sf::Mouse::isButtonPressed(sf::Mouse::Left))
        {
            tmp_cliquedroit = true;
            Cliquedroit = false;
        }
        Event event;
        while (app->pollEvent(event))
        {
            if (event.type == Event::Closed)
                app->close();
            if(!enPause)
            {
                if(event.type == Event::KeyPressed && event.key.code == sf::Keyboard::Space && !m_unite[unite]->IsFire())
                {
                    m_unite[unite]->Evenement(5, app, m_terre, this);
                }
                if(event.type == Event::KeyPressed && event.key.code == sf::Keyboard::Left)
                {
                    fenetre->deplacer(-2, m_terre);
                    vue_suivit = false;
                }
                if(event.type == Event::KeyPressed && event.key.code == sf::Keyboard::Right)
                {
                    fenetre->deplacer(2, m_terre);
                    vue_suivit = false;
                }
            }
            if((event.type == Event::MouseWheelMoved && event.mouseWheel.delta == 1) || (event.type == Event::KeyPressed && event.key.code == sf::Keyboard::Up))
                equipe_id[equipe_actu].Suivant();
            if((event.type == Event::MouseWheelMoved && event.mouseWheel.delta == -1) || (event.type == Event::KeyPressed && event.key.code == sf::Keyboard::Down))
                equipe_id[equipe_actu].Precedent();
            if(m_unite[unite]->GetType() == INFANT && event.type == Event::KeyPressed && event.key.code == sf::Keyboard::E)
            {
                for(int i(0);i<m_batiment_neutre.size();i++)
                {
                    if(m_unite[unite]->IsInBatiment())
                    {
                        m_batiment_neutre[i].RemoveUnite(m_unite[unite], unite);
                    }
                    else
                    {
                        if(m_batiment_neutre[i].GetVie() > 0)
                        {
                            sf::Sprite uni = m_unite[unite]->GetSurface();
                            if(m_batiment_neutre[i].IsCollideUnite(uni))
                            {
                                m_batiment_neutre[i].AjouterUnite(m_unite[unite],unite);
                            }
                        }
                    }
                }
            }
            if(event.type == Event::KeyPressed && event.key.code != sf::Keyboard::Right && event.key.code != sf::Keyboard::Left)
            {
                vue_suivit = true;
            }
            if(event.type == Event::KeyPressed && event.key.code == sf::Keyboard::Num1)
            {
                m_unite[unite]->Evenement(10, app, m_terre, this);
            }
            if(event.type == Event::KeyPressed && event.key.code == sf::Keyboard::Num2)
            {
                m_unite[unite]->Evenement(11, app, m_terre, this);
            }
            if(event.type == Event::KeyPressed && event.key.code == sf::Keyboard::Num5)
            {
                AjouterBatiment(equipe_actu+1,-1,0,m_unite[unite]->GetPosition());
            }
            if(event.type == Event::KeyPressed && typePause == 3)
            {
                typePause = 1;
                enPause = false;
            }
            if(event.type == Event::KeyPressed && event.key.code == sf::Keyboard::Escape && !m_unite[unite]->IsFire() && typePause != 3)
            {
                if(enPause)
                {
                    enPause = false;
                }
                else
                {
                    enPause = true;
                    typePause = 1;
                }
            }
        }
        if(vue_suivit && !enPause && typePause != 4)
        {
            if(m_unite[equipe_id[equipe_actu].GetUniteActuel()]->IsFire())
            {
                fenetre->setPosition(m_unite[equipe_id[equipe_actu].GetUniteActuel()]->GetRoquettePosition().x, m_terre);
            }
            else
            {
                fenetre->setPosition(m_unite[equipe_id[equipe_actu].GetUniteActuel()]->GetPosition().x, m_terre);
            }
        }
        //Fin evenement
        app->clear();
        app->setView(app->getDefaultView());
        m_terre->afficherFond(app);
        app->setView(fenetre->getvue());
        m_terre->afficherTerrain(app, fenetre->getvue().getCenter().x-400);
        //m_terre->refresh(app);
        for(int i(0); i<nombre_joueur; i++)
        {
            if(equipe_id[i].GetAlive())
            {
                for(int j(0); j<equipe_id[i].GetNumberBatiment(); j++)
                {
                    sf::Vector2f vecteur_tmp = equipe_id[i].GetBatiment(j).GetPosition();
                    if(equipe_id[i].GetBatiment(j).GetVie() > 0)
                    {
                        if(vecteur_tmp.x < fenetre->getvue().getCenter().x+400
                           && vecteur_tmp.x >fenetre->getvue().getCenter().x-400)
                           {
                               if(j == equipe_id[i].GetNumberBatiment()-1&&equipe_id[i].GetNumberBatiment()>1)
                               {
                                    sf::Vector2f position_tmp = Vector2f(fenetre->getvue().getCenter().x - (fenetre->getvue().getSize().x / 2) + sf::Mouse::getPosition().x
                                                                         , fenetre->getvue().getCenter().y - (fenetre->getvue().getSize().y / 2) + sf::Mouse::getPosition().y);
                                    if(equipe_id[i].CanPlaceBatiment(position_tmp, m_terre))
                                    {
                                        if(Cliquedroit)
                                        {
                                            equipe_id[i].AddBatiment(m_unite);
                                        }
                                        else
                                            equipe_id[i].PlacerBatiment(j, true, false, Vector2f(position_tmp.x, m_terre->cherTerrain(position_tmp.x,-1)));
                                    }
                                    else
                                    {
                                        equipe_id[i].PlacerBatiment(j, false, false, Vector2f(position_tmp.x, m_terre->cherTerrain(position_tmp.x,-1)));
                                    }
                               }

                               equipe_id[i].Afficher(app, j, true);
                           }
                           else
                           {
                               equipe_id[i].Afficher(app,j,false);
                           }
                    }
                }
            }
        }
        for(int i(0); i<m_batiment_neutre.size();i++)
        {
                sf::Vector2f vecteur_tmp = m_batiment_neutre[i].GetPosition();
                if(m_batiment_neutre[i].GetVie() > 0)
                {
                    if(vecteur_tmp.x < fenetre->getvue().getCenter().x+400
                        && vecteur_tmp.x >fenetre->getvue().getCenter().x-400)
                        {
                            m_batiment_neutre[i].Afficher(app, true);
                        }
                        else
                            m_batiment_neutre[i].Afficher(app, true);
                }
        }
        for(int i(0); i<m_unite.size(); i++)
        {
            if(!m_unite[i]->IsDead() && m_unite[i]->GetPosition().x < fenetre->getvue().getCenter().x+400 && m_unite[i]->GetPosition().x > fenetre->getvue().getCenter().x-400)
                m_unite[i]->Afficher(app, sf::Vector2f(0,0),m_terre,this,m_spriteunite, true);
            else if(m_unite[i]->IsFire())
                m_unite[i]->Afficher(app, sf::Vector2f(0,0),m_terre,this,m_spriteunite, true);
            else if (!m_unite[i]->IsDead())
                m_unite[i]->Afficher(app, sf::Vector2f(0,0),m_terre,this,m_spriteunite, false);
        }
        m_unite[unite]->AfficherGui(app);
        rafraichir_position();
        if(!enPause && typePause != 4)
        {
            sprite_curseur.setPosition(m_unite[unite]->GetPosition() - Vector2f(0,100));
        }
        app->draw(sprite_curseur);
        app->setView(app->getDefaultView());
        if(enPause && typePause != 4)
        {
            if(typePause == 1)
                pause(app, sf::Vector2f(sf::Mouse::getPosition().x, sf::Mouse::getPosition().y), Cliquedroit, ToucheOn, 1);
            else if(typePause == 3)
                pause(app, sf::Vector2f(sf::Mouse::getPosition().x, sf::Mouse::getPosition().y), Cliquedroit, ToucheOn, 3);
        }
        else
        {
            if(typePause == 4)
                attente++;

            if(attente > 50 && typePause == 4)
            {
                typePause = 3;
                attente = 0;
            }
            if(CollisionBoiteVector(sprite_fond, souris)&&curseur_interface<120)
            {
                curseur_interface+=5;
            }
            else if(curseur_interface>50 && !CollisionBoiteVector(sprite_fond, souris))
            {
                curseur_interface-=5;
            }
            texte_statut.setPosition(souris-Vector2f(0,20));
            sprite_vie_unite.setPosition(20,600-45-curseur_interface+120);
            sprite_puissance.setPosition(20,600-30-curseur_interface+120);
            sprite_vie_base.setPosition(190,600-30-curseur_interface+120);
            sprite_fond_devant.setPosition(0,600-curseur_interface);
            sprite_fond.setPosition(0,600-curseur_interface);
            texte_nbbatiment.setString("Batiment : " + to_string(equipe_id[equipe_actu].GetNumberBatiment()));
            texte_nbbatiment.setPosition(190,600-50-curseur_interface+120);
            texte_point.setString("Argent : " + to_string(equipe_id[equipe_actu].GetPoint()));
            texte_point.setPosition(285,600-50-curseur_interface+120);
            app->draw(sprite_fond);
            app->draw(sprite_puissance);
            sprite_vie_unite.setTextureRect(IntRect(0,10,m_unite[unite]->GetVie()/m_unite[unite]->GetVieMax()*145,20));
            sprite_vie_base.setTextureRect(IntRect(0,0,equipe_id[equipe_actu].GetBatiment(0).GetVie()/2000*190,10));
            app->draw(sprite_vie_unite);
            app->draw(sprite_vie_base);
            app->draw(sprite_fond_devant);
            app->draw(texte_nbbatiment);
            app->draw(texte_point);
            if(m_unite[unite]->GetType() == INFANT)
            switch(m_unite[unite]->GetSousType())
            {
                case SOLDAT:
                sprite_armurerie.setPosition(450,600-40-curseur_interface+120);
                if(equipe_id[equipe_actu].GetPoint() >1600)
                {
                    if(CollisionBoiteVector(sprite_armurerie,souris))
                    {
                        if(Cliquedroit)
                            m_unite[unite]->Evenement(10, app, m_terre, this);
                        texte_statut.setString("Armurerie");
                        sprite_armurerie.setTextureRect(IntRect(20,0,40,20));
                    }
                    else
                    {
                    if(CollisionBoiteVector(sprite_armurerie,souris))
                        texte_statut.setString("Il vous faut au moin 1600 d'argent...");
                        sprite_armurerie.setTextureRect(IntRect(0,0,20,20));
                    }
                }
                else
                {
                    sprite_armurerie.setTextureRect(IntRect(40,0,60,20));
                }
                app->draw(sprite_armurerie);
                sprite_armurerie.setPosition(480,600-40-curseur_interface+120);
                if(equipe_id[equipe_actu].GetPoint() >1600)
                {
                    if(CollisionBoiteVector(sprite_armurerie,souris))
                    {
                        if(Cliquedroit)
                            m_unite[unite]->Evenement(10, app, m_terre, this);
                        texte_statut.setString("Armurerie");
                        sprite_armurerie.setTextureRect(IntRect(20,0,40,20));
                    }
                    else
                    {
                        sprite_armurerie.setTextureRect(IntRect(0,0,20,20));
                    }
                }
                else
                {
                    if(CollisionBoiteVector(sprite_armurerie,souris))
                        texte_statut.setString("Il vous faut au moin 1600 d'argent...");
                    sprite_armurerie.setTextureRect(IntRect(40,0,60,20));
                }
                app->draw(sprite_armurerie);
                sprite_c4.setPosition(540,600-40-curseur_interface+120);
                if(m_unite[unite]->GetSpe(0))
                {
                    for(int i(0); i < m_spriteunite.size(); i++)
                    {
                        if(m_unite[unite]->GetEquipe() != m_unite[i]->GetEquipe() && CollisionBoiteSensible(m_spriteunite[unite], m_spriteunite[i]))
                        {
                            sprite_c4.setTextureRect(IntRect(0,100,20,120));
                            if(CollisionBoiteVector(sprite_c4, souris))
                            {
                                texte_statut.setString("Utiliser C4 (600)");
                                sprite_c4.setTextureRect(IntRect(20,100,40,120));
                                if(sf::Mouse::isButtonPressed(sf::Mouse::Left))
                                {
                                    m_unite[unite]->Evenement(12, app, m_terre, this);
                                }
                            }
                        }
                    }
                }
                else
                {
                    if(equipe_id[equipe_actu].GetPoint() >= 600)
                    {
                        if(CollisionBoiteVector(sprite_c4, souris))
                        {
                            texte_statut.setString("Acheter C4 (600)");
                            sprite_c4.setTextureRect(IntRect(20,120,40,140));
                            if(sf::Mouse::isButtonPressed(sf::Mouse::Left))
                            {
                                equipe_id[equipe_actu].Achat(600);
                                m_unite[unite]->SetSpe(true, m_unite[unite]->GetSpe(1));
                            }
                        }
                    }
                    else
                    {
                        if(CollisionBoiteVector(sprite_c4, souris))
                            texte_statut.setString("Pas assez d'argent pour acheter une C4 (600)");
                        sprite_c4.setTextureRect(IntRect(40,120,60,140));
                    }
                }
                app->draw(sprite_c4);
                break;

                case MEDIC:
                sprite_hopital.setPosition(450,600-40-curseur_interface+120);
                if(equipe_id[equipe_actu].GetPoint() >1200)
                {
                    if(CollisionBoiteVector(sprite_hopital,souris))
                    {
                        if(Cliquedroit)
                            m_unite[unite]->Evenement(10, app, m_terre, this);
                        texte_statut.setString("Hopital");
                        sprite_hopital.setTextureRect(IntRect(20,40,40,60));
                    }
                    else
                    {
                        sprite_hopital.setTextureRect(IntRect(0,40,20,60));
                    }
                }
                else
                {
                    if(CollisionBoiteVector(sprite_hopital,souris))
                        texte_statut.setString("Il vous faut au moin 1200 d'argent...");
                    sprite_hopital.setTextureRect(IntRect(40,40,60,60));
                }
                app->draw(sprite_hopital);
                sprite_hopital.setPosition(480,600-40-curseur_interface+120);
                if(equipe_id[equipe_actu].GetPoint() >1200)
                {
                    if(CollisionBoiteVector(sprite_hopital,souris))
                    {
                        if(Cliquedroit)
                            m_unite[unite]->Evenement(10, app, m_terre, this);
                        texte_statut.setString("Hopital");
                        sprite_hopital.setTextureRect(IntRect(20,40,40,60));
                    }
                    else
                    {
                        sprite_hopital.setTextureRect(IntRect(0,40,20,60));
                    }
                }
                else
                {
                    if(CollisionBoiteVector(sprite_hopital,souris))
                        texte_statut.setString("Il vous faut au moin 1200 d'argent...");
                    sprite_hopital.setTextureRect(IntRect(40,40,60,60));
                }
                app->draw(sprite_hopital);
                break;


                case TECH:
                sprite_garage.setPosition(450,600-40-curseur_interface+120);
                if(equipe_id[equipe_actu].GetPoint() >1600)
                {
                    if(CollisionBoiteVector(sprite_garage,souris))
                    {
                        if(Cliquedroit)
                            m_unite[unite]->Evenement(10, app, m_terre, this);
                        texte_statut.setString("Garage");
                        sprite_garage.setTextureRect(IntRect(20,60,40,80));
                    }
                    else
                    {
                        sprite_garage.setTextureRect(IntRect(0,60,20,80));
                    }
                }
                else
                {
                    if(CollisionBoiteVector(sprite_garage,souris))
                        texte_statut.setString("Il vous faut au moin 1300 d'argent...");
                    sprite_garage.setTextureRect(IntRect(40,60,60,80));
                }
                app->draw(sprite_garage);
                sprite_garage.setPosition(480,600-40-curseur_interface+120);
                if(equipe_id[equipe_actu].GetPoint() >1600)
                {
                    if(CollisionBoiteVector(sprite_garage,souris))
                    {
                        if(Cliquedroit)
                            m_unite[unite]->Evenement(10, app, m_terre, this);
                        texte_statut.setString("Garage");
                        sprite_garage.setTextureRect(IntRect(20,60,40,80));
                    }
                    else
                    {
                        sprite_garage.setTextureRect(IntRect(0,60,20,80));
                    }
                }
                else
                {
                    if(CollisionBoiteVector(sprite_garage,souris))
                        texte_statut.setString("Il vous faut au moin 1300 d'argent...");
                    sprite_garage.setTextureRect(IntRect(40,60,60,80));
                }
                app->draw(sprite_garage);
                break;


                case SNIPER:
                sprite_radar.setPosition(450,600-40-curseur_interface+120);
                if(equipe_id[equipe_actu].GetPoint() >1600)
                {
                    if(CollisionBoiteVector(sprite_radar,souris))
                    {
                        if(Cliquedroit)
                            m_unite[unite]->Evenement(10, app, m_terre, this);
                        texte_statut.setString("Radar");
                        sprite_radar.setTextureRect(IntRect(20,20,40,40));
                    }
                    else
                    {
                        sprite_radar.setTextureRect(IntRect(0,20,20,40));
                    }
                }
                else
                {
                    if(CollisionBoiteVector(sprite_radar,souris))
                        texte_statut.setString("Il vous faut au moin 1500 d'argent...");
                    sprite_radar.setTextureRect(IntRect(40,20,60,40));
                }
                app->draw(sprite_radar);
                sprite_radar.setPosition(480,600-40-curseur_interface+120);
                if(equipe_id[equipe_actu].GetPoint() >1600)
                {
                    if(CollisionBoiteVector(sprite_radar,souris))
                    {
                        if(Cliquedroit)
                            m_unite[unite]->Evenement(10, app, m_terre, this);
                        texte_statut.setString("Radar");
                        sprite_radar.setTextureRect(IntRect(20,20,40,40));
                    }
                    else
                    {
                        sprite_radar.setTextureRect(IntRect(0,20,20,40));
                    }
                }
                else
                {
                    if(CollisionBoiteVector(sprite_radar,souris))
                        texte_statut.setString("Il vous faut au moin 1500 d'argent...");
                    sprite_radar.setTextureRect(IntRect(40,20,60,40));
                }
                app->draw(sprite_radar);
                break;
            }
            sprite_pompe.setPosition(510,600-40-curseur_interface+120);
            if(equipe_id[equipe_actu].GetPoint() >750)
            {
                if(CollisionBoiteVector(sprite_pompe,souris))
                {
                    if(Cliquedroit)
                        AjouterBatiment(equipe_actu+1,-1,0,m_unite[unite]->GetPosition());
                    texte_statut.setString("Ajoutez une pompe pour gagnez de l'argent");
                    sprite_pompe.setTextureRect(IntRect(20,80,40,100));
                }
                else
                {
                    sprite_pompe.setTextureRect(IntRect(0,80,20,100));
                }
            }
            else
            {
                if(CollisionBoiteVector(sprite_pompe,souris))
                    texte_statut.setString("Il vous faut au moin 750 d'argent...");
                sprite_pompe.setTextureRect(IntRect(40,80,60,100));
            }
            app->draw(sprite_pompe);
            app->draw(texte_statut);
            int temporaire = 0;
            for(int equipe(0); equipe < 4; equipe++)
            {
                if(equipe_id[equipe].GetAlive())
                {
                    sprite_fondequipe[equipe].setPosition(temporaire*200,10);
                    sprite_devantequipe[equipe].setPosition(temporaire*200-10,5);
                    sprite_vieequipe[equipe].setPosition(temporaire*200,10);
                    texte_equipe[equipe].setPosition(temporaire*200+10,-10);
                    app->draw(sprite_fondequipe[equipe]);
                    app->draw(sprite_vieequipe[equipe]);
                    app->draw(sprite_devantequipe[equipe]);
                    app->draw(texte_equipe[equipe]);
                    temporaire++;
                }
            }
        }
        if(sf::Keyboard::isKeyPressed(sf::Keyboard::Tab))
        {
            pause(app, sf::Vector2f(sf::Mouse::getPosition().x, sf::Mouse::getPosition().y), Cliquedroit, ToucheOn, 2);
        }
        app->display();
    }
}
void Game::degat(int explosion, sf::Vector2f position, int degat, bool balle, int id_balle, bool to_infant)
{
    int i(0),j(0), taux;
    int k(0);
    int m_degat = degat;
    sf::Vector2f m_position;
    std::vector<int> unite_touche;
  /*  for(i=-explosion;i<explosion;i++)
    {
        taux = (int)(sqrt(pow(explosion, 2) - pow(i,2)));
        for(j=0; j<taux;j++)
        {
            if(position.x+i <m_terre->GetTextureSize().x-2 && position.x+i > 2)
            {
                if(position.y+j < 598 && position.y+j > 2)
                {
                    m_terre->setPixel(position.x+i,position.y+j);
                }
                if(position.y-j < 598 && position.y-j > 2)
                {
                    m_terre->setPixel(position.x+i,position.y-j);
                }
            }
        }
    }*/
    if(!balle)
    {
        for(i=-explosion/2;i<explosion/2;i++)
        {
            taux = (int)(sqrt(pow(50, 2) - pow(i,2)));
            for(j=0; j<taux;j++)
            {
                if(position.x+i <m_terre->GetTextureSize().x-2 && position.x+i > 2)
                {
                        for(k=0; k<m_unite.size(); k++)
                        {
                            m_position.x = (int)(m_unite[k]->GetPosition().x);
                            m_position.y = (int)(m_unite[k]->GetPosition().y);
                            if(CollisionBoiteVector(m_spriteunite[k],sf::Vector2f(position.x+i, position.y+j)))
                            {
                                if(unite_touche.size() != 0)
                                {
                                    bool existe = false;
                                    for(int p(0);p<unite_touche.size();p++)
                                    {
                                        if(k==unite_touche[p])
                                            existe = true;
                                    }
                                    if(!existe)
                                        unite_touche.push_back(k);
                                }
                                else
                                {
                                    unite_touche.push_back(k);
                                }
                            }
                        }
                        for(k=0; k<m_unite.size(); k++)
                        {
                            if(CollisionBoiteVector(m_spriteunite[k],sf::Vector2f(position.x+i, position.y+j)))
                            {
                                if(unite_touche.size() != 0)
                                {
                                    bool existe = false;
                                    for(int p(0);p<unite_touche.size();p++)
                                    {
                                        if(k==unite_touche[p])
                                            existe = true;
                                    }
                                    if(!existe)
                                        unite_touche.push_back(k);
                                }
                                else
                                {
                                    unite_touche.push_back(k);
                                }
                                /*int inflige = sqrt(pow(m_unite[k]->GetPosition().x-position.x,2)+pow(m_unite[k]->GetPosition().y-position.y,2));
                                m_unite[k]->Degat(inflige);*/
                            }
                        }
                }
            }
        }
        for(int p(0);p<unite_touche.size();p++)
        {
            sf::Vector2f degatposition = m_unite[unite_touche[p]]->GetPosition();
            float inflige = m_degat - sqrt(pow(degatposition.x-position.x,2)+pow(degatposition.y-position.y,2));
            cout << "degat " << inflige << endl;
            if(inflige <0)
                inflige = 0;
            if(equipe_id[m_unite[unite_touche[p]]->GetEquipe()-1].IsExplosion(1))
                inflige /= 2;
            if(equipe_id[m_unite[equipe_id[equipe_actu].GetUniteActuel()]->GetEquipe()-1].IsExplosion(0))
                inflige *= 1.5;

            m_unite[unite_touche[p]]->Degat(inflige);
        }
    }
    else
    {
        if((to_infant && m_unite[id_balle]->GetType() == INFANT) || !to_infant)
            m_unite[id_balle]->Degat(m_degat);
    }
}
void Game::finTire()
{
    rafraichir_equip();
    sprite_puissance.setTexture(image_jauge);
    sprite_puissance.setTextureRect(IntRect(0,20,75,30));
}
void Game::rafraichir_position()
{
    for(int i(0); i<m_spriteunite.size(); i++)
    {
         m_spriteunite[i] = m_unite[i]->GetSurface();

        if(m_unite[i]->IsDead())
         m_spriteunite[i].setPosition(sf::Vector2f(0,0));
    }
}
void Game::rafraichir_equip()
{
    //Recherche si toute les equips sont en vie. sinon mise à niveau
    int i(0), j(0), pas(0);
    equipe_id[equipe_actu].RafraichirEffect(m_unite, m_terre);
    for(i=0;i<4;i++)
    {
        cout << i << endl;
        if(equipe_id[i].GetAlive())
        {
            equipe_id[i].Rafraichir(m_unite);
            cout << "ok" << endl;
        }
    }
    int ancien_equipe = equipe_actu;
    for(i=1;i<=4;i++)
    {
        if(equipe_actu+i >= 4)
            equipe_actu-=4;

        if(equipe_id[equipe_actu+i].GetAlive())
        {
            equipe_actu+=i;
            i=5;
        }
    }
    if(equipe_actu == ancien_equipe)
    {
        gagner();
    }
    //Mise à niveau de la valeur de equipe actu
    typePause = 4;
    enPause = true;
}
void Game::gagner()
{
    equipe_gagnante = 1;
}
void Game::pause(sf::RenderWindow *app,sf::Vector2f souris, bool Clique, bool Even, int type)
{
    if(type == 1) // Menu Pause
    {
        //Bouton Reprendre
        if(souris.x < 500 && souris.x > 300 && souris.y > 200 && souris.y < 250)
        {
            sprite_boutonreprendre.setTextureRect(IntRect(200,50,400,100));
            if(Clique)
            {
                enPause = false;
            }
        }
        else
        {
            sprite_boutonreprendre.setTextureRect(IntRect(0,50,200,100));
        }
        //Bouton option
        if(souris.x < 500 && souris.x > 300 && souris.y > 250 && souris.y < 300)
        {
            sprite_boutonoption.setTextureRect(IntRect(200,150,400,200));
            if(Clique)
            {
            }
        }
        else
        {
            sprite_boutonoption.setTextureRect(IntRect(0,150,200,200));
        }
        //Bouton Retour Menu
        if(souris.x < 500 && souris.x > 300 && souris.y > 300 && souris.y < 350)
        {
            sprite_boutonretourmenu.setTextureRect(IntRect(200,100,400,150));
            if(Clique)
            {
                enPause = false;
            }
        }
        else
        {
            sprite_boutonretourmenu.setTextureRect(IntRect(0,100,200,150));
        }
        //Bouton quitter
        if(souris.x < 500 && souris.x > 300 && souris.y > 350 && souris.y < 400)
        {
            sprite_boutonquitter.setTextureRect(IntRect(200,0,400,50));
            if(Clique)
            {
                app->close();
            }
        }
        else
        {
            sprite_boutonquitter.setTextureRect(IntRect(0,0,200,50));
        }
        app->draw(sprite_fondpause);
        app->draw(sprite_boutonoption);
        app->draw(sprite_boutonquitter);
        app->draw(sprite_boutonreprendre);
        app->draw(sprite_boutonretourmenu);
    }
    else if(type == 2) // Menu tableau des equipes
    {
        int pas(0);
        ostringstream oss;
        app->draw(sprite_tableauequipe);
        if(equipe_id[0].GetAlive())
        {
            texte_nomequipe.setColor(Color(255,0,0));
            texte_nomequipe.setString("Equipe : Rouge");
            texte_nomequipe.setPosition(140,140);
            texte_nomunite.setColor(Color(0,0,0));
            app->draw(texte_nomequipe);
            pas += 22;
            for(int i(0);i<equipe_id[0].GetUniteTotal();i++)
            {
                if(equipe_id[0].GetUnite(i) != -1)
                {
                    if(m_unite[equipe_id[0].GetUnite(i)]->GetType() == TANK)
                    {
                        oss << "Tank : ";
                    }
                    if(m_unite[equipe_id[0].GetUnite(i)]->GetType() == INFANT)
                    {
                        oss << "Infanterie : ";
                    }
                    if(m_unite[equipe_id[0].GetUnite(i)]->GetType() == HELICO)
                    {
                        oss << "Hélicoptère : ";
                    }
                    oss << m_unite[equipe_id[0].GetUnite(i)]->GetVie() << "/" << m_unite[equipe_id[0].GetUnite(i)]->GetVieMax();
                    texte_nomunite.setString(oss.str());
                    texte_nomunite.setPosition(150,140+pas);
                    app->draw(texte_nomunite);
                    pas+=18;
                    oss.str("");
                }
            }
        }
        if(equipe_id[1].GetAlive())
        {
            texte_nomequipe.setColor(Color(0,255,0));
            texte_nomequipe.setString("Equipe : Bleu");
            texte_nomequipe.setPosition(140,140+pas);
            texte_nomunite.setColor(Color(0,0,0));
            app->draw(texte_nomequipe);
            pas += 22;
            for(int i(0);i<equipe_id[1].GetUniteTotal();i++)
            {
                if(equipe_id[1].GetUnite(i) != -1)
                {
                    if(m_unite[equipe_id[1].GetUnite(i)]->GetType() == TANK)
                    {
                        oss << "Tank : ";
                    }
                    if(m_unite[equipe_id[1].GetUnite(i)]->GetType() == INFANT)
                    {
                        oss << "Infanterie : ";
                    }
                    if(m_unite[equipe_id[1].GetUnite(i)]->GetType() == HELICO)
                    {
                        oss << "Helicoptere : ";
                    }
                    oss << m_unite[equipe_id[1].GetUnite(i)]->GetVie() << "/" << m_unite[equipe_id[1].GetUnite(i)]->GetVieMax();
                    texte_nomunite.setString(oss.str());
                    texte_nomunite.setPosition(150,140+pas);
                    app->draw(texte_nomunite);
                    pas+=18;
                    oss.str("");
                }
            }
        }
        if(equipe_id[2].GetAlive())
        {
            texte_nomequipe.setColor(Color(0,0,255));
            texte_nomequipe.setString("Equipe : Vert");
            texte_nomequipe.setPosition(140,140+pas);
            texte_nomunite.setColor(Color(0,0,0));
            app->draw(texte_nomequipe);
            pas += 22;
            for(int i(0);i<equipe_id[2].GetUniteTotal();i++)
            {
                if(equipe_id[2].GetUnite(i) != -1)
                {
                    if(m_unite[equipe_id[2].GetUnite(i)]->GetType() == TANK)
                    {
                        oss << "Tank : ";
                    }
                    if(m_unite[equipe_id[2].GetUnite(i)]->GetType() == INFANT)
                    {
                        oss << "Infanterie : ";
                    }
                    if(m_unite[equipe_id[2].GetUnite(i)]->GetType() == HELICO)
                    {
                        oss << "Hélicoptère : ";
                    }
                    oss << m_unite[equipe_id[2].GetUnite(i)]->GetVie() << "/" << m_unite[equipe_id[2].GetUnite(i)]->GetVieMax();
                    texte_nomunite.setString(oss.str());
                    texte_nomunite.setPosition(150,140+pas);
                    app->draw(texte_nomunite);
                    pas+=18;
                    oss.str("");
                }
            }
        }
        if(equipe_id[3].GetAlive())
        {
            texte_nomequipe.setColor(Color(255,255,0));
            texte_nomequipe.setString("Equipe : Jaune");
            texte_nomequipe.setPosition(140,140+pas);
            texte_nomunite.setColor(Color(0,0,0));
            app->draw(texte_nomequipe);
            pas += 22;
            for(int i(0);i<equipe_id[3].GetUniteTotal();i++)
            {
                if(equipe_id[3].GetUnite(i) != -1)
                {
                    if(m_unite[equipe_id[3].GetUnite(i)]->GetType() == TANK)
                    {
                        oss << "Tank : ";
                    }
                    if(m_unite[equipe_id[3].GetUnite(i)]->GetType() == INFANT)
                    {
                        oss << "Infanterie : ";
                    }
                    if(m_unite[equipe_id[3].GetUnite(i)]->GetType() == HELICO)
                    {
                        oss << "Hélicoptère : ";
                    }
                    oss << m_unite[equipe_id[3].GetUnite(i)]->GetVie() << "/" << m_unite[equipe_id[3].GetUnite(i)]->GetVieMax();
                    texte_nomunite.setString(oss.str());
                    texte_nomunite.setPosition(150,140+pas);
                    app->draw(texte_nomunite);
                    pas+=15;
                    oss.str("");
                }
            }
        }
    }
    else if(type == 3) // Changement d'équipe, le tir à été emit
    {
        switch(equipe_actu)
        {
            case 0:
                texte_changementequipe.setString("ROUGE");
                texte_changementequipe.setColor(Color(255,0,0));
                break;

            case 1:
                texte_changementequipe.setString("BLEU");
                texte_changementequipe.setColor(Color(0,0,255));
                break;

            case 2:
                texte_changementequipe.setString("VERT");
                texte_changementequipe.setColor(Color(0,255,0));
                break;

            case 3:
                texte_changementequipe.setString("JAUNE");
                texte_changementequipe.setColor(Color(255,255,0));
                break;
        }
        texte_changementequipe.setCharacterSize(50);
        texte_changementequipe.setPosition(400-texte_changementequipe.getLocalBounds().width/2,140);
        app->draw(sprite_changementequipe);
        app->draw(texte_changementequipe);
    }
}
std::vector<Unite*> Game::GetUnite()
{
    return m_unite;
}
void Game::AjouterBatiment(int equipe, int type, int sous_type, sf::Vector2f position)
{
    equipe_id[equipe-1].CreateBatiment(type,sous_type, position, m_terre);
}
Batiment::Batiment(string image, int vie, int type)
{
    m_placer = false;
    m_placeable = false;
    m_vie = vie;
    m_t = 0;
    en_creation = true;
    curseur = 0;
    m_viemax = vie;
    m_type = type;
    m_nombre_unite = 0;
    m_position = sf::Vector2f(0,0);
    if(!image_batiment.loadFromFile(image.c_str()) || !image_batimenton.loadFromFile(image.c_str()) || !image_batimentoff.loadFromFile(image.c_str()) || image.c_str() == "")
    {
        cout << "Impossible de charger l'image du batiment.." << endl;
    }
    image_batiment.setSmooth(false);
    image_batimenton.setSmooth(false);
    image_batimentoff.setSmooth(false);
    sprite_batimenton.setTexture(image_batimenton);
    sprite_batiment.setTexture(image_batiment);
    sprite_batimentoff.setTexture(image_batimentoff);

    sprite_batimenton.setColor(sf::Color(0,255,0));
    sprite_batiment.setColor(sf::Color(255,255,255,128));
    sprite_batimenton.setColor(sf::Color(255,0,0));

    sprite_batiment.setOrigin(image_batiment.getSize().x/2,image_batiment.getSize().y);
    sprite_batiment.setScale(1.2,1.2);
    sprite_batimenton.setOrigin(image_batimenton.getSize().x/2,image_batimenton.getSize().y);
    sprite_batimentoff.setOrigin(image_batimenton.getSize().x/2,image_batimenton.getSize().y);
    sprite_batimentoff.setScale(1.2,1.2);
    sprite_batimenton.setScale(1.2,1.2);

    if(!m_imagevie.loadFromFile("picture/map/vie.png"))
    {
        cout << "Impossible de charger l'image de la vie du batiment..." << endl;
    }
    else
    {
        m_spritevie.setTexture(m_imagevie);
        m_spritevie.setScale(2,2);
    }
}
Batiment::~Batiment()
{

}
void Batiment::ChargerCaractere(string fichier)
{
    ifstream fiche(fichier.c_str());
    int pos(0), x(0);
    while(!fiche.eof())
    {
        string mot;
        fiche >> mot;
        if(pos == 0)
        {
            m_nombre_unite++;
            x = atoi(mot.c_str());
            pos = 1;
        }
        else
        {
            pos = 0;
            position_unite.push_back(sf::Vector2f(x, atoi(mot.c_str())));
            cout << position_unite[position_unite.size()-1].y << endl;
        }
    }
}
bool Batiment::Placeable(float x, Terrain *terre, int max, int min)
{
    if(x > max || x < min)
    {
        m_placeable = false;
        return false;
    }
    int y1 = terre->cherTerrain(x+image_batiment.getSize().x/2,-1);
    int y2 = terre->cherTerrain(x-image_batiment.getSize().x/2,-1);
    if(y1-y2 < 10 && y1-y2>-10)
    {
        m_placeable = true;
        return true;
    }
    else
    {
        m_placeable = false;
        return false;
    }
}
bool Batiment::IsCollideUnite(sf::Sprite unite)
{
    if(CollisionBoiteSensible(unite, sprite_batiment) != -1)
    {
        return true;
    }
    else
    {
        return false;
    }
}
void Batiment::Placer(float x, float y, bool placer)
{
    if(!m_placer)
    {
        m_placer = placer;
        m_position = sf::Vector2f(x, y);
        //m_position = sf::Vector2f(x,terre->cherTerrain(x,-1));
        sprite_batiment.setPosition(m_position);
        sprite_batimentoff.setPosition(m_position);
        sprite_batimenton.setPosition(m_position);
        m_spritevie.setPosition(m_position+Vector2f(-30,-sprite_batiment.getLocalBounds().width - 40));
    }
}
void Batiment::Afficher(sf::RenderWindow *app, bool visible)
{
    if(en_creation && m_placer)
    {
        int tailleX = image_batiment.getSize().x-1;
        int collone = 0;
        int random = rand() % tailleX - 1;
        int y(0);
        int test_complete(0);
        for(int i(0); i< image_batiment.getSize().x;i++)
        {
            int x = i;
            y = image_batiment.getSize().y-curseur-1;
            if(!image_batiment.copyToImage().getPixel(x,y).a == 0)
                image_batiment.copyToImage().setPixel(x,y,Color(image_batiment.copyToImage().getPixel(x,y).r,image_batiment.copyToImage().getPixel(x,y).g,image_batiment.copyToImage().getPixel(x,y).b,255));
        }
        curseur++;
        if(curseur >= image_batiment.getSize().y)
        {
            en_creation = false;
        }
        int i(0);/*
        for(i=0;i<tailleX;i++)
        {
            if(image_batiment.GetPixel(i,image_batiment.GetHeight()-curseur+1).a > 200 || image_batiment.GetPixel(i,image_batiment.GetHeight()-curseur+1).a == 0)
            {
                collone++;
            }
        }
        cout << tailleX << endl;
        if(collone >= i)
        {
            curseur+=2;
            cout << curseur << ":" << image_batiment.GetHeight() << ". Colone = " << collone << endl;
            if(curseur == image_batiment.GetHeight())
                en_creation = false;
        }*/
        collone = 0;
    }
    if(visible)
    {
        for(int i(0);i<sprite_unite.size();i++)
        {
            app->draw(sprite_unite[i]);
        }
        app->draw(sprite_batiment);
        app->draw(m_spritevie);
        if(!m_placer)
        {
            if(m_placeable)
                app->draw(sprite_batimenton);
            else
                app->draw(sprite_batimentoff);
        }
    }
}
int Batiment::GetVie()
{
    return m_vie;
}
int Batiment::GetType()
{
    return m_type;
}
sf::Sprite Batiment::GetSprite()
{
    return sprite_batiment;
}
void Batiment::Degat(float degat)
{
    m_vie -= degat;
    if(m_vie<0)
        m_vie = 0;
    float v = m_vie/m_viemax*30;
    v--;

    m_spritevie.setTexture(m_imagevie);
    m_spritevie.setTextureRect(IntRect(0,0,(int)(v),4));
    m_spritevie.setScale(2,2);
}
sf::Vector2f Batiment::GetPosition()
{
    return m_position;
}
void Batiment::AjouterUnite(Unite* uniter, int id)
{
    if(position_unite.size()>sprite_unite.size())
    {
        sprite_unite.push_back(sf::Sprite());
        sprite_unite[sprite_unite.size()] = uniter->GetSurface();
        uniter->SetPosition(m_position+sf::Vector2f(position_unite[0].x,-position_unite[0].y));
        uniter->SetInBatiment(true);
        unite_in_place.push_back(id);
    }
}
void Batiment::RemoveUnite(Unite* uniter, int id)
{
    for(int i(0);i<unite_in_place.size();i++)
    {
        if(unite_in_place[i] == id)
        {
            unite_in_place.erase(unite_in_place.begin()+i);
            sprite_unite.erase(sprite_unite.begin()+i);
        }
        uniter->SetInBatiment(false);
        uniter->SetPosition(m_position);
    }
}
void Batiment::SetPlaceable(bool placeable)
{
    m_placeable = placeable;
}
